package com.yc.utils;

import com.yc.bean.TestOption;
import com.yc.bean.TestQuestion;
import com.yc.bean.UserTestAnswer;
import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 测评评分工具类
 */
@Slf4j
public class TestScoringUtil {

    /**
     * 计算总分
     * @param answers 用户答案列表
     * @param questions 题目列表（包含是否反向计分信息）
     * @return 总分
     */
    public static int calculateTotalScore(List<UserTestAnswer> answers, List<TestQuestion> questions) {
        int totalScore = 0;
        Map<Long, TestQuestion> questionMap = new HashMap<>();
        
        // 创建题目映射 - 修复：使用questionId作为key
        for (TestQuestion question : questions) {
            questionMap.put(question.getQuestionId(), question);
        }
        
        for (UserTestAnswer answer : answers) {
            TestQuestion question = questionMap.get(answer.getQuestionId());
            int score = answer.getOptionValue();
            
            // 如果是反向计分题目
            if (question != null && question.getIsReverse() != null && question.getIsReverse() == 1) {
                score = reverseScore(score, getMaxOptionValue(question));
                log.debug("反向计分题目 {}: 原始分数 {} -> 反向分数 {}", answer.getQuestionId(), answer.getOptionValue(), score);
            }
            
            totalScore += score;
        }
        
        log.debug("总分计算完成: {}", totalScore);
        return totalScore;
    }

    /**
     * 反向计分
     * @param originalScore 原始分数
     * @param maxScore 最大分值
     * @return 反向计分后的分数
     */
    private static int reverseScore(int originalScore, int maxScore) {
        return maxScore + 1 - originalScore;
    }

    /**
     * 获取题目选项的最大分值
     * @param question 题目（需要包含选项）
     * @return 最大分值
     */
    private static int getMaxOptionValue(TestQuestion question) {
        if (question.getOptions() == null || question.getOptions().isEmpty()) {
            return 4; // 默认4分制
        }
        
        return question.getOptions().stream()
                .mapToInt(TestOption::getValue)
                .max()
                .orElse(4);
    }

    /**
     * 根据分数确定等级
     * @param score 总分
     * @param testType 测评类型
     * @return 等级描述
     */
    public static String determineLevel(int score, String testType) {
        switch (testType.toLowerCase()) {
            case "sas":
            case "anxiety":
                return determineAnxietyLevel(score);
            case "sds": 
            case "depression":
                return determineDepressionLevel(score);
            case "stress":
                return determineStressLevel(score);
            default:
                return determineGeneralLevel(score);
        }
    }

    /**
     * 焦虑量表等级判定
     * 修复后的SAS量表分数范围: 35-65分
     * (15个正向题×1-4分 + 5个反向题×4-1分)
     */
    private static String determineAnxietyLevel(int score) {
        if (score < 45) {
            return "正常";
        } else if (score < 53) {
            return "轻度焦虑";
        } else if (score < 61) {
            return "中度焦虑";
        } else {
            return "重度焦虑";
        }
    }

    /**
     * 抑郁量表等级判定
     */
    private static String determineDepressionLevel(int score) {
        if (score < 53) {
            return "正常";
        } else if (score < 63) {
            return "轻度抑郁";
        } else if (score < 73) {
            return "中度抑郁";
        } else {
            return "重度抑郁";
        }
    }

    /**
     * 压力量表等级判定
     */
    private static String determineStressLevel(int score) {
        if (score < 25) {
            return "压力较小";
        } else if (score < 50) {
            return "压力适中";
        } else if (score < 75) {
            return "压力较大";
        } else {
            return "压力过大";
        }
    }

    /**
     * 通用等级判定（百分制）
     */
    private static String determineGeneralLevel(int score) {
        if (score >= 90) {
            return "优秀";
        } else if (score >= 80) {
            return "良好";
        } else if (score >= 70) {
            return "中等";
        } else if (score >= 60) {
            return "及格";
        } else {
            return "待改善";
        }
    }

    /**
     * 生成测评建议
     * @param level 等级
     * @param score 分数
     * @param testType 测评类型
     * @return 建议内容
     */
    public static String generateSuggestions(String level, int score, String testType) {
        StringBuilder suggestions = new StringBuilder();
        
        switch (testType.toLowerCase()) {
            case "sas":
            case "anxiety":
                suggestions.append(generateAnxietySuggestions(level, score));
                break;
            case "sds":
            case "depression":
                suggestions.append(generateDepressionSuggestions(level, score));
                break;
            case "stress":
                suggestions.append(generateStressSuggestions(level, score));
                break;
            default:
                suggestions.append(generateGeneralSuggestions(level, score));
                break;
        }
        
        return suggestions.toString();
    }

    private static String generateAnxietySuggestions(String level, int score) {
        switch (level) {
            case "正常":
                return "您的焦虑水平在正常范围内。建议继续保持规律作息，适当运动，培养兴趣爱好。";
            case "轻度焦虑":
                return "您存在轻度焦虑。建议学习放松技巧（如深呼吸、冥想），增加社交活动，保持规律锻炼。";
            case "中度焦虑":
                return "您存在中度焦虑。建议寻求心理咨询师的专业帮助，学习系统的焦虑应对技巧，改善生活方式。";
            case "重度焦虑":
                return "您存在重度焦虑。强烈建议立即就医，寻求专业的心理治疗或药物治疗，同时争取家人朋友的支持。";
            default:
                return "请根据您的具体情况，寻求适当的帮助和支持。";
        }
    }

    private static String generateDepressionSuggestions(String level, int score) {
        switch (level) {
            case "正常":
                return "您的情绪状态良好。建议继续保持积极的生活态度，多参与社交活动。";
            case "轻度抑郁":
                return "您可能存在轻度抑郁情绪。建议增加户外活动，培养兴趣爱好，与亲友多交流。";
            case "中度抑郁":
                return "您可能存在中度抑郁。建议寻求心理咨询，考虑认知行为治疗等专业干预。";
            case "重度抑郁":
                return "您可能存在重度抑郁。强烈建议立即寻求专业医疗帮助，进行综合治疗。";
            default:
                return "请关注自己的情绪变化，必要时寻求专业帮助。";
        }
    }

    private static String generateStressSuggestions(String level, int score) {
        switch (level) {
            case "压力较小":
                return "您的压力水平较低。建议继续保持良好的工作生活平衡。";
            case "压力适中":
                return "您的压力水平适中。建议学习时间管理技巧，适当放松。";
            case "压力较大":
                return "您的压力较大。建议调整工作节奏，学习压力管理技巧，寻求支持。";
            case "压力过大":
                return "您的压力过大。建议及时调整生活方式，必要时寻求专业帮助。";
            default:
                return "请关注压力管理，保持身心健康。";
        }
    }

    private static String generateGeneralSuggestions(String level, int score) {
        switch (level) {
            case "优秀":
                return "您的表现很优秀！请继续保持。";
            case "良好":
                return "您的表现良好，可以在某些方面进一步提升。";
            case "中等":
                return "您的表现处于中等水平，有一定的提升空间。";
            case "及格":
                return "您的表现刚刚及格，建议多加努力。";
            case "待改善":
                return "您的表现有待改善，建议寻求相关指导和帮助。";
            default:
                return "请根据具体情况制定改进计划。";
        }
    }

    /**
     * 计算标准分（T分数）
     * @param rawScore 原始分数
     * @param mean 均值
     * @param standardDeviation 标准差
     * @return T分数
     */
    public static double calculateTScore(int rawScore, double mean, double standardDeviation) {
        return 50 + (rawScore - mean) / standardDeviation * 10;
    }

    /**
     * 计算百分位数
     * @param score 分数
     * @param allScores 所有分数
     * @return 百分位
     */
    public static double calculatePercentile(int score, List<Integer> allScores) {
        if (allScores == null || allScores.isEmpty()) {
            return 50.0; // 默认中位数
        }
        
        long count = allScores.stream().filter(s -> s < score).count();
        return (double) count / allScores.size() * 100;
    }
} 